home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Sound / mhi_dev / MHIplay / MHIplay.c next >
Encoding:
C/C++ Source or Header  |  2001-03-30  |  4.2 KB  |  172 lines
  1.  
  2. /************************************************/
  3. /*                                              */
  4. /* MHIplay: A simple example how to play        */
  5. /*          multibuffered data via MHI          */
  6. /*                                              */
  7. /*          Revision 1.0 by Thomas Wenzel       */
  8. /*                                              */
  9. /************************************************/
  10.  
  11. #include <stdio.h>
  12. #include <exec/libraries.h>
  13. #include <exec/memory.h>
  14. #include <proto/exec.h>
  15. #include <proto/dos.h>
  16. #include <dos/dos.h>
  17.  
  18. #include <proto/mhi.h>
  19. #include <libraries/mhi.h>
  20.  
  21.  
  22. #define NUMBUFS    8
  23. #define BUFSIZE    128*128
  24.  
  25. static char Version[]="\0$VER: MHIplay 1.0 (30.03.2001)\0";
  26.  
  27. struct Library *MHIBase;
  28.  
  29. int main(int argc, char *argv[]) {
  30.     char    PC[5] = "-\\|/";
  31.     ULONG Progress;
  32.     BYTE    MHISignal;
  33.     ULONG    MHIMask, Signals;
  34.     APTR     MHIHandle;
  35.     BPTR    InFile;
  36.     APTR    Buffer[NUMBUFS];
  37.     ULONG    CurrentLen;
  38.     APTR    CurrentBuffer;
  39.     BOOL    MemOk;
  40.     BOOL    Done;
  41.     ULONG ReturnCode;
  42.     long i;
  43.  
  44.     ReturnCode=0;
  45.     
  46.     if(argc != 3) {
  47.         printf("Usage: MHIplay <driver> <file>\n");
  48.         return(5);
  49.     }
  50.  
  51.     if(MHIBase = OpenLibrary(argv[1], 0)) {
  52.         MHISignal = AllocSignal(-1);
  53.         if(MHISignal != -1) {
  54.             MHIMask = 1L << MHISignal;
  55.             if(MHIHandle = MHIAllocDecoder(FindTask(NULL), MHIMask)) {
  56.                 printf("\nDriver details:\n");
  57.                 printf("Name:    %s\n", MHIQuery(MHIQ_DECODER_NAME));
  58.                 printf("Version: %s\n", MHIQuery(MHIQ_DECODER_VERSION));
  59.                 printf("Author:  %s\n", MHIQuery(MHIQ_AUTHOR));
  60.                 printf("\n");
  61.  
  62.                 /************************/
  63.                 /* Allocate all buffers */
  64.                 /************************/
  65.                 MemOk=TRUE;
  66.                 for(i=0; i<NUMBUFS; i++) {
  67.                     Buffer[i] = AllocVec(BUFSIZE, MEMF_CLEAR);
  68.                     if(!Buffer[i]) MemOk=FALSE;
  69.                 }
  70.                 if(MemOk) {
  71.                     if(InFile=Open(argv[2], MODE_OLDFILE)) {
  72.  
  73.                         Done=FALSE;
  74.  
  75.                         /**************/
  76.                         /* Preloading */
  77.                         /**************/
  78.                         printf("Preloading.\n");
  79.                         for(i=0; i<NUMBUFS; i++) {
  80.                             if(CurrentLen = Read(InFile, Buffer[i], BUFSIZE)) {
  81.                                 MHIQueueBuffer(MHIHandle, Buffer[i], CurrentLen);
  82.                                 if(CurrentLen != BUFSIZE) Done=TRUE;
  83.                             }
  84.                         }
  85.  
  86.                         /******************/
  87.                         /* Playback start */
  88.                         /******************/
  89.                         printf("Starting playback.\n");
  90.                         MHIPlay(MHIHandle);
  91.                         Progress=0;
  92.  
  93.                         /*************/
  94.                         /* Main loop */
  95.                         /*************/
  96.                         while(!Done) {
  97.                             printf("Playing [%c]\r", PC[Progress]);
  98.                             flushall();
  99.                             Progress ++;
  100.                             if(Progress > 3) Progress=0;
  101.  
  102.                             Signals=Wait(MHIMask | SIGBREAKF_CTRL_C);
  103.                             if(Signals & SIGBREAKF_CTRL_C) break;
  104.  
  105.                             if(Signals & MHIMask) {
  106.                                 /* Reload and queue all empty buffers */
  107.                                 for(i=0; i<NUMBUFS; i++) {
  108.                                     if(CurrentBuffer = MHIGetEmpty(MHIHandle)) {
  109.                                         if(CurrentLen = Read(InFile, CurrentBuffer, BUFSIZE)) {
  110.                                             MHIQueueBuffer(MHIHandle, CurrentBuffer, CurrentLen);
  111.                                         }
  112.                                         if(CurrentLen != BUFSIZE) Done=TRUE;
  113.                                     }
  114.                                 }
  115.  
  116.                                 /* Restart if needed */
  117.                                 if(MHIGetStatus(MHIHandle) == MHIF_OUT_OF_DATA) MHIPlay(MHIHandle);
  118.                             }
  119.                         }
  120.  
  121.                         /*************************************/
  122.                         /* Wait for all buffers to run empty */
  123.                         /*************************************/
  124.                         if(!(Signals & SIGBREAKF_CTRL_C)) {
  125.                             printf("EOF reached. Waiting for end of stream.\n");
  126.                             while((MHIGetStatus(MHIHandle) == MHIF_PLAYING)) {
  127.                                 Signals=Wait(MHIMask | SIGBREAKF_CTRL_C);
  128.                                 if(Signals & SIGBREAKF_CTRL_C) break;
  129.                             }
  130.                         }
  131.  
  132.                         /*****************/
  133.                         /* Playback stop */
  134.                         /*****************/
  135.                         printf("Stopping playback.\n");
  136.                         MHIStop(MHIHandle);
  137.                         Close(InFile);
  138.                     }
  139.                     else {
  140.                         printf("Can't open file!\n");
  141.                     }
  142.                 }
  143.                 else {
  144.                     printf("Out of memory!\n");
  145.                     ReturnCode=5;
  146.                 }
  147.                 /********************/
  148.                 /* Free all buffers */
  149.                 /********************/
  150.                 for(i=0; i<NUMBUFS; i++) {
  151.                     if(Buffer[i]) FreeVec(Buffer[i]);
  152.                 }
  153.                 MHIFreeDecoder(MHIHandle);
  154.             }
  155.             else {
  156.                 printf("Can't allocate decoder!\n");
  157.                 ReturnCode=5;
  158.             }
  159.             FreeSignal(MHISignal);
  160.         }
  161.         else {
  162.             printf("No signals available! Crazy man!\n");
  163.             ReturnCode=5;
  164.         }
  165.         CloseLibrary(MHIBase);
  166.     }
  167.     else {
  168.         printf("Can't open MHI driver \"%s\"\n", argv[1]);
  169.     }
  170.     return(ReturnCode);
  171. }
  172.